"    Input:  {
              Comes from 'compile', 'run' and 'clean' functions

              sub_action             - clean, compile, run

              (host_os)              - host OS (detect, if omitted)
              (target_os)            - OS module to check (if omitted, analyze host)
              (device_id)            - device id if remote (such as adb)

              (target)               - target machine added via 'ck add machine' with prepared target description
                                       (useful to create farms of machines for crowd-benchmarking and crowd-tuning using CK)

              (device_cfg)           - extra device cfg (if empty, will be filled in from 'machine' module description)

              (compute_platform_id)  - if !='', set env['CK_COMPUTE_PLATFORM_ID']
              (compute_device_id)    - if !='', set env['CK_COMPUTE_DEVICE_ID']

              path                   - path
              meta                   - program description

              (tmp_dir)              - if !='', use it instead of 'tmp' dir to compile and run code
              (generate_rnd_tmp_dir) - if 'yes', generate random tmp directory to compile and run program
                                       (useful during crowd-tuning)

              (run_batch_name)       - if !='', use this batch name instead of randomly generated one

              (compiler_vars)        - dict with set up compiler flags (-D var)
                                       they will update the ones defined as default in program description ...

              (no_vars)              - skip compiler vars (if you want to use default ones from the sources) ...

              (compiler_tags)        - extra compiler tags

              (remove_compiler_vars) - list of compiler vars to remove

              (extra_env_for_compilation) - set environment variables before compiling program

              (flags)                - compile flags
              (lflags)               - link flags

              (speed)                - if 'yes', compile for speed (use env CK_OPT_SPEED from compiler)
              (size)                 - if 'yes', compile for size (use env CK_OPT_SIZE from compiler)

              (compile_type)         - static or dynamic (dynamic by default;
                                         however takes compiler default_compile_type into account)
                  or
              (static or dynamic)

              (use_clang_opt)        - use Clang opt optimizer

              (repeat)               - repeat kernel via environment CT_REPEAT_MAIN if supported

              (sudo)                 - if 'yes', force using sudo
                                       (if not set up in OS, use ${CK_SUDO_INIT}, ${CK_SUDO_PRE}, ${CK_SUDO_POST})

              (affinity)             - set processor affinity for tihs program run (if supported by OS - see "affinity" in OS)
                                       examples: 0 ; 0,1 ; 0-3 ; 4-7  (the last two can be useful for ARM big.LITTLE arhictecture

              (clean)                - if 'yes', clean tmp directory before using
              (skip_clean_after)     - if 'yes', do not remove run batch
              (keep)                 - the same as skip_clean_after

              (repo_uoa)             - program repo UOA
              (module_uoa)           - program module UOA
              (data_uoa)             - program data UOA

              (params)               - dictionary with parameters passed via pre/post processing to third-party tools
                                       for example, to configure ARM Workload Automation
              (params.{KEY})         - set params[KEY]=value (user-friendly interface via CMD)

              (misc)                 - misc  dict
              (characteristics)      - characteristics/features/properties
              (env)                  - preset environment
              (env.{KEY})            - set env[KEY]=value (user-friendly interface via CMD)

              (deps.{KEY})           - set deps[KEY]["uoa']=value (user-friendly interface via CMD to set any given dependency)
              (preset_deps)          - dict with {"KEY":"UOA"} to preset dependencies

              (post_process_script_uoa) - run script from this UOA
              (post_process_subscript)  - subscript name
              (post_process_params)     - (string) add params to CMD

              (deps)                 - already resolved deps (useful for auto-tuning)
              (deps_cache)           - list of already resolved deps (useful to automate crowd-benchmarking and crowd-tuning)
              (reuse_deps)           - if 'yes', reuse deps by keys

              (dep_add_tags.{KEY})   - extra tags added to specific subdictionary of deps{} for this particular resolution session

              (cmd_key)              - CMD key
              (dataset_uoa)          - UOA of a dataset
              (dataset_file)         - dataset filename (if more than one inside one entry - suggest to have a UID in name)

              (extra_env)            - extra environment before running code as string
              (pre_run_cmd)          - pre CMD for binary
              (extra_run_cmd)        - extra CMD (can use $#key#$ for autotuning)
              (debug_run_cmd)        - substitute CMD with this one - usually useful for debugging to pre-set env for all deps
              (run_cmd_substitutes)  - dict with substs ($#key#$=value) in run CMD (useful for CMD autotuning)

              (console)              - if 'yes', output to console

              (skip_device_init)     - if 'yes', do not initialize device

              (skip_calibration)     - if 'yes', skip execution time calibration (make it around 4.0 sec)
              (calibration_time)     - calibration time in string, 4.0 sec. by default
              (calibration_max)      - max number of iterations for calibration, 10 by default

              (pull_only_timer_files) - if 'yes', pull only timer files, but not output files
                                        (useful for remove devices during statistical repetition)

              (energy)                - if 'yes', start energy monitoring (if supported) using script ck-set-power-sensors
                                       Also, set compiler var CK_MONITOR_ENERGY=1 and run-time var CK_MONITOR_ENERGY=1

                                       Note: files, monitored for energy, are defined in system environment.
                                             For example, odroid .profile as:
                                               export CK_ENERGY_FILES="/sys/bus/i2c/drivers/INA231/3-0040/sensor_W;/sys/bus/i2c/drivers/INA231/3-0041/sensor_W;/sys/bus/i2c/drivers/INA231/3-0044/sensor_W;/sys/bus/i2c/drivers/INA231/3-0045/sensor_W;"

              (run_output_files)              - extra list of output files (useful to add in pipeline to collect profiling from Android mobile, for example)

              (extra_post_process_cmd)        - append at the end of execution bat (for example, to call gprof ...)

              (statistical_repetition_number) - int number of current (outside) statistical repetition
                                                to avoid pushing data to remote device if !=0 ...
              (autotuning_iteration)          - int number of current autotuning iteration
                                                to avoid pushing some data to remote device if !=0 ...
              (skip_dataset_copy)             - if 'yes', dataset stays the same across iterations of pipeline, so do not copy to remote again

              (unparsed)                      - if executing ck run program ... -- (unparsed params), add them to compile or run ...

              (compile_timeout)               - (sec.) - kill compile job if too long
              (run_timeout)                   - (sec.) - kill run job if too long

              (add_rnd_extension_to_bin)      - if 'yes', add random extension to binary and record list
              (add_save_extension_to_bin)     - if 'yes', add '.save' to bin to save during cleaning ...

              (skip_print_timers)             - if 'yes', skip printing fine-grain timers after execution

              (skip_file_print)               - skip file printing (if 'print_files_after_run' list is in program meta)

              (skip_output_validation)        - skip validation of output (dangerous during auto-tuning -
                                                  some optimizations may break semantics or change accuracy)
              (output_validation_repo)        - output validation repo UOA (when recording new output)
              (program_output_uoa)            - use this UOA to check/record program output 
                                                (to have the same output entry for groups of similar programs)

              (overwrite_reference_output)    - if 'yes', overwrite reference output (useful if broken)

              (quiet)                         - if 'yes', automatically provide default answer to all questions when resolving dependencies ...
              (random)                        - if 'yes', select deps randomly (useful for quite crowd-tuning / DNN classification)

              (install_to_env)       - install dependencies to env instead of CK-TOOLS (to keep it clean)!

              (safe)                 - safe mode when searching packages first instead of detecting already installed soft
                                       (to have more deterministic build)

              (skip_exec)            - if 'yes', do not clean output files and skip exec to be able to continue

              (record_deps)          - if !='', record dependencies to this file
            }

    Output: {
              return          - return code =  0, if successful
                                            >  0, if error
              (error)         - error text if return > 0

              misc            - updated misc dict
              characteristics - updated characteristics
              env             - updated environment
              deps            - resolved deps, if any
            }

"